﻿using System;
using System.Linq;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Diagnostics;
//Librerias Arquitectura
using Com.Binaria.Core;
using Com.Binaria.Core.Base;
using Com.Binaria.Core.Dto;
using Com.Binaria.Core.Util;
using Com.Binaria.Core.Datos;
using Com.Binaria.Core.Exceptions;
using Com.Binaria.Core.Enumeracion;
//Librerias Proyecto
using Com.Binaria.SISCOB.Funcional.DTO;
using Com.Binaria.SISCOB.DTO;
using Com.Binaria.SISCOB.DAO;

namespace Com.Binaria.SISCOB.Dom
{
/// <summary>
///	clase de egreso dom
/// </summary>
public partial class EgresoDom : IEgresoDom
{
	#region campos privados
    /// <summary>
    /// Constante que almacena el prefijo de la aplicacion
    /// </summary>
    private const String CLASS_PREFIX = "Com.Binaria.SISCOB.Dom.EgresoDom";
	#endregion
	
    #region campos publicos
        /// <summary>
        /// campo publico que contiene una instancia del objeto (EgresoDAO) encargado del acceso a datos
        /// </summary>
        public IEgresoDAO iEgresoDAO;
        public IDocumentoTransaccionDom iDocumentoTransaccionDom;
    #endregion

    #region constructores
    /// <summary>
    /// constructor por defecto del objeto
    /// </summary>
    public EgresoDom()
    {
		
	}
    #endregion


	
    #region metodos privados
	
	/// <summary>
    /// metodo que permite generar clonaciones de los objetos almacenados en la lista generica 
    /// </summary>
    /// <param name="p_Egresos">lista generica con elementos egreso a copiar</param>
    /// <returns>Objeto view con elementos egreso copiados</returns>
    private List<EgresoDTO> CopiaEgreso(List<EgresoDTO> p_Egresos)
    {
		//Prefijo del Metodo
		const string MPREFIX = " [CopiaEgreso]";
		//Crea lista de objetos de salida
        List<EgresoDTO> RespuestaCopia = new List<EgresoDTO>();		
        try
        {
			//Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);
			//Valido que la lista no venga en NULL
            AssertNull.notNullOrEmpty(p_Egresos);
			//Valido que la lista tenga elementos
			AssertNull.notNullOrEmpty(p_Egresos.Count);
			//Recorro la lista de objetos
			foreach (EgresoDTO registro in p_Egresos)
			{
				//Valido que el registro no este vacio
				AssertNull.notNullOrEmpty(registro);
				//Agrega el registro a la lista de respuesta
				RespuestaCopia.Add(registro.Clone());
			}
            //Registro log de termino OK del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Ok);
            //Registro log de termino del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
        return RespuestaCopia;
    }


    /// <summary>
    /// metodo que permite buscar todas los elementos egreso existentes
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
	/// <param name="p_Filtro">Datos para realizar una busqueda por filtros</param>
    /// <returns>objeto contenedor de la informacion generada por la accion ejecutada</returns>
    private List<EgresoDTO> Buscar(ContextoDTO p_Contexto, EgresoDTO p_Filtro)
    {
        //Prefijo del Metodo
        const string MPREFIX = " [Buscar]";
		//Crea lista de objetos de salida
        List<EgresoDTO> RespuestaBuscar = new List<EgresoDTO>();		
        try
        {
            //Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);
            //Obtengo la lista de objetos
            RespuestaBuscar = iEgresoDAO.Find(p_Filtro);
            //Registro log de ejecucion el termino del metodo
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
        catch (System.Data.DataException de)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ACCESO_PERSISTENCIA"), de, TraceEventType.Critical);
        }
		catch (ManagerException me)
		{
			throw (me);
		}
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
        return RespuestaBuscar;
    }
	
	/// <summary>
	/// metodo que permite buscar el elemento egreso que coincide con el id
	/// </summary>
	/// <param name="p_Contexto">informacion del contexto</param>
	/// <param name="p_IdEgreso">Id de la egreso</param>
	/// <returns>objeto contenedor de la informacion generada por la accion ejecutada</returns>
    private EgresoDTO Buscar(ContextoDTO p_Contexto, System.Int32? p_IdEgreso)
    {
        //Prefijo del Metodo
        const string MPREFIX = " [Buscar]";
        //Crea lista de objetos de salida
        EgresoDTO RespuestaBuscar = new EgresoDTO();
        try
        {
            //Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);
            //Obtengo la lista de objetos
            RespuestaBuscar = iEgresoDAO.GetByID((System.Int32)p_IdEgreso);
            //Registro log de ejecucion el termino del metodo
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
        catch (System.Data.DataException de)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ACCESO_PERSISTENCIA"), de, TraceEventType.Critical);
        }
		catch (ManagerException me)
		{
			throw (me);
		}
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
        return RespuestaBuscar;
    }

	/// <summary>
	/// metodo que permite buscar todas los elementos egreso existentes
	/// </summary>
	/// <param name="p_Contexto">informacion del contexto</param>
	/// <returns>objeto contenedor de la informacion generada por la accion ejecutada</returns>
    private List<EgresoDTO> Buscar(ContextoDTO p_Contexto)
    {
        //Prefijo del Metodo
        const string MPREFIX = " [Buscar]";
		//Crea lista de objetos de salida
        List<EgresoDTO> RespuestaBuscar = new List<EgresoDTO>();		
        try
        {
            //Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);
            //Obtengo la lista de objetos
            RespuestaBuscar = iEgresoDAO.GetAll();
            //Registro log de ejecucion el termino del metodo
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
        catch (System.Data.DataException de)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ACCESO_PERSISTENCIA"), de, TraceEventType.Critical);
        }
		catch (ManagerException me)
		{
			throw (me);
		}
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
        return RespuestaBuscar;
    }


    /// <summary>
    /// metodo al cual se le delega la insercion de elementos de egreso
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
    /// <param name="p_Egresos">elementos de tipo egreso a insertar</param>
    private List<EgresoDTO> InsertarEgreso(ContextoDTO p_Contexto, List<EgresoDTO> p_Egresos)
    {
		//Prefijo del Metodo
        const string MPREFIX = " [InsertarEgreso]";
        try
        {
			//Registro log de inicio del proceso
			Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);
	
			//Valida que exista informacion a insertar
			AssertNull.notNullOrEmpty(p_Egresos);

			//Crea objeto para almacenar los datos existentes
			List<EgresoDTO> ListaEgreso = new List<EgresoDTO>();

            //try
            //{
                //Obtiene la lista de Egreso
            //    ListaEgreso = Buscar(p_Contexto);
            //}
            //catch (ManagerException me)
            //{
                //Capturo el error cuando no existen datos
            //    if (!me.Message.Substring(0, me.Message.IndexOf(";")).Equals("3001"))
            //    {
            //        throw (me);
            //    }
            //}

	        //Objeto que contiene la cantidad de objetos que existen
            int cant = 0;
            foreach (EgresoDTO Egreso in p_Egresos)
            {
				//Valida que Egreso contenga los datos minimos
						AssertNull.notNullOrEmpty(Egreso);
						AssertNull.notNullOrEmpty(Egreso.EsManual);
						AssertNull.notNullOrEmpty(Egreso.Estado);

				//Busca valores unicos que no se pueden repetir en un registro
	            //cant = ListaEgreso.Where(dto => GetMatchingByUniqueValues(dto, Egreso)).Count();

                //if (!cant.Equals(0))
                //{
                //    break;
                //}
			}

            //Valida que no existan valores unicos
            if (cant.Equals(0))
            {
                //Creo el nuevo registro y almaceno el valor devuelto en el objeto creado
                p_Egresos = iEgresoDAO.Insert(p_Egresos.ToArray()).ToList();
				
				foreach (EgresoDTO Egreso in p_Egresos)
            	{
					//Valido que el valor devuelto corresponda a un indice
					if (Egreso.Id.Equals(0))
					{
						//Registro log de ejecucion con problemas
						Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
						//Genero error debido a que no existen datos a entregar
						throw new ManagerException(Factoria.GetMessage("DOM_ERROR_INSERTAR_BASE"), TraceEventType.Warning);
					}
				}

			}
			else
			{
				//Registro log de ejecucion con problemas
                Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
                //Genero error debido a que no existen datos a entregar
                throw new ManagerException(Factoria.GetMessage("DOM_DATOS_UNICOS_REPETIDOS"), TraceEventType.Warning);
            }

			//Registro log de termino OK del proceso
			Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Ok);
			//Registro log de ejecucion el termino del metodo
			Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
		}
		catch (ManagerException me)
		{
			throw (me);
		}
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
        catch (System.Data.DBConcurrencyException dbce)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_INSERT"), dbce, TraceEventType.Error);
        }
        catch (System.Data.DataException de)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ACCESO_PERSISTENCIA"), de, TraceEventType.Critical);
        }
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
		return p_Egresos;
    }
	
    /// <summary>j
    /// metodo al cual se le delega la actualizacion de elementos de egreso
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
    /// <param name="p_Egresos">elementos de tipo egreso a actualizar</param>
    private void ModificarEgreso(ContextoDTO p_Contexto, List<EgresoDTO> p_Egresos)
    {
		//Prefijo del Metodo
		const string MPREFIX = " [ModificarEgreso]";

        try
        {
			//Registro log de inicio del proceso
			Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);
	
			//Valida que exista informacion a insertar
			AssertNull.notNullOrEmpty(p_Egresos);

			//Crea objeto para almacenar los datos existentes
			//List<EgresoDTO> ListaEgreso = new List<EgresoDTO>();

            //try
            //{
            //    //Obtiene la lista de Egreso
            //    ListaEgreso = Buscar(p_Contexto);
            //}
            //catch (ManagerException me)
            //{
            //    //Administra la estructura de errores por codigo
            //    switch (me.Message.Substring(0, me.Message.IndexOf(";")))
            //    {
            //        case "3001":
            //            throw new ManagerException(Factoria.GetMessage("DOM_DATOS_NO_ENCONTRADOS"), me, TraceEventType.Warning);
            //        default:
            //            throw(me);
            //    }
            //}

	        //Objeto que contiene la cantidad de objetos que existen
            int cant = 0;
            foreach (EgresoDTO Egreso in p_Egresos)
            {
				//Valida que Egreso contenga los datos minimos
						AssertNull.notNullOrEmpty(Egreso);
						AssertNull.notNullOrEmpty(Egreso.EsManual);
						AssertNull.notNullOrEmpty(Egreso.Estado);

				//Busca valores unicos que no sepueden repetir en un registro
	            //cant = ListaEgreso.Where(dto => GetMatchingByUniqueValues(dto, Egreso)).Count();

                if (!cant.Equals(0))
                {
                    break;
                }
				else
				{
					//Creo objeto para recepcionar respuesta de la busqueda
					EgresoDTO EgresoEncontrada = new EgresoDTO();

					try
					{
						//Realizo la busqueda en cache
						EgresoEncontrada = Buscar(p_Contexto, (System.Int32?)Egreso.Id);
                    }
                    catch (ManagerException me)
                    {
                        //Administra la estructura de errores por codigo
                        switch (me.Message.Substring(0, me.Message.IndexOf(";")))
                        {
                            case "3001":
                                throw new ManagerException(Factoria.GetMessage("DOM_DATOS_NO_ENCONTRADOS"), me, TraceEventType.Warning);
                        }
                    }
					
					//Verifico si el registro existe en cache
					if (EgresoEncontrada == null)
					{
						//Registro log de ejecucion con problemas
						Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
						//Genero error debido a que no existen datos a entregar
						throw new ManagerException(Factoria.GetMessage("DOM_DATOS_NO_ENCONTRADOS"), TraceEventType.Warning);
					}
				}
			}
			
			//Valida que no existan valores unicos
            if (cant.Equals(0))
            {
				//Actualizo la informacion existente
				iEgresoDAO.Update(p_Egresos.ToArray());

			}
			else
			{
				//Registro log de ejecucion con problemas
                Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
                //Genero error debido a que no existen datos a entregar
                throw new ManagerException(Factoria.GetMessage("DOM_DATOS_UNICOS_REPETIDOS"), TraceEventType.Warning);
                //Cambio valor de insertar a falso
            }

			//Registro log de termino OK del proceso
			Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Ok);
			//Registro log de ejecucion el termino del metodo
			Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
        catch (System.Data.DBConcurrencyException dbce)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_UPDATE"), dbce, TraceEventType.Error);
        }
        catch (System.Data.DataException de)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ACCESO_PERSISTENCIA"), de, TraceEventType.Critical);
        }
		catch (ManagerException me)
		{
			throw (me);
		}
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
		catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
    }
	
    /// <summary>
    /// metodo al cual se le delega la eliminacion de elementos de tipo egreso
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
    /// <param name="p_Egresos">elementos de tipo egreso a eliminar</param>
    private void EliminarEgreso(ContextoDTO p_Contexto, List<EgresoDTO> p_Egresos)
    {
        //Prefijo del Metodo
        const string MPREFIX = " [EliminarEgreso]";
		
        try
        {
			//Registro log de inicio del proceso
			Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);
			//Creo Clase para enviar los Id de aviso a eliminar
			List<System.Int32> IdEgresos = new List<System.Int32>();
	        foreach (EgresoDTO Egreso in p_Egresos)
            {
				//Valida que Egreso contenga los datos minimos
				AssertNull.notNullOrEmpty(Egreso);
				AssertNull.notNullOrEmpty(Egreso.Id);

				//Creo objeto para recepcionar respuesta de la busqueda
				EgresoDTO EgresoEncontrada = new EgresoDTO();

				try
				{
					//Realizo la busqueda
					EgresoEncontrada = Buscar(p_Contexto, (System.Int32?)Egreso.Id);
				}
				catch (ManagerException me)
				{
					//Adminstra la estructura de errores por codigo
					switch (me.Message.Substring(0, me.Message.IndexOf(";")))
					{
						case "3001":
							throw new ManagerException(Factoria.GetMessage("DOM_DATOS_NO_ENCONTRADOS"), me, TraceEventType.Warning);
                        default:
                            throw(me);
					}
				}
                //Verifico si el registro existe en cache
				if (EgresoEncontrada != null)
				{
					IdEgresos.Add((System.Int32)Egreso.Id);
				}
            }
			
			if (IdEgresos.Count>0)
			{
				//Elimino los registros
				iEgresoDAO.Delete(IdEgresos.ToArray());
			}

			//Registro log de termino OK del proceso
			Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Ok);
			//Registro log de ejecucion el termino del metodo
			Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
		}
        catch (System.Data.DBConcurrencyException dbce)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_UPDATE"), dbce, TraceEventType.Error);
        }
        catch (System.Data.DataException de)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ACCESO_PERSISTENCIA"), de, TraceEventType.Critical);
        }
		catch (ManagerException me)
		{
			throw (me);
		}
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
		catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
    }
	
	#region metodos privados estaticos
	/// <summary>
    /// metodo que permite buscar lo elementos de tipo egreso coincidentes en base a sus propiedades que contienen valores unicos
    /// </summary>
    /// <param name="p_Egreso">elemento de tipo egreso a buscar</param>
    /// <param name="p_EgresoComparer">elemento de tipo egreso a comparar</param>
    /// <returns>retorna valor booleano indicando existencia de igualdad</returns>
    private static bool GetMatchingByUniqueValues(EgresoDTO p_Egreso, EgresoDTO p_EgresoComparer)
    {
		//Este metodo valida que la informacion no este repetida
		bool returnValue = false;
		returnValue = 
                (p_Egreso.EsManual.ToString().ToUpper() == p_EgresoComparer.EsManual.ToString().ToUpper())
				&&
                (p_Egreso.Estado.ToString().ToUpper() == p_EgresoComparer.Estado.ToString().ToUpper())
				&&
                (p_EgresoComparer.Id.Equals(default(System.Int32?)) || p_Egreso.Id != p_EgresoComparer.Id);
		return returnValue;
    }	
	
    /// <summary>
    /// metodo que permite buscar todos los elementos de tipo egreso coincidentes en base a las propiedades del objeto
    /// </summary>
    /// <param name="p_Egreso">elemento de tipo egreso a comparar</param>
    /// <param name="p_Filtro">filtro de elemento de tipo egreso a comparar</param>
    /// <returns>retorna valor booleano indicando existencia de igualdad</returns>
    private static bool FindMatching(EgresoDTO p_Egreso, EgresoDTO p_Filtro)
    {
		bool returnValue = false;

		returnValue =		
                (p_Filtro.Id == null || (p_Egreso.Id == null?null: p_Egreso.Id.ToString().ToUpper()) == p_Filtro.Id.ToString().ToUpper())
				&&
                (p_Filtro.EsManual == null || (p_Egreso.EsManual == null?null: p_Egreso.EsManual.ToString().ToUpper()) == p_Filtro.EsManual.ToString().ToUpper())
				&&
                (p_Filtro.Estado == null || (p_Egreso.Estado == null?null: p_Egreso.Estado.ToString().ToUpper()) == p_Filtro.Estado.ToString().ToUpper())
					;

		return returnValue;
    }	
	#endregion metodos privados estaticos
	#endregion metodos privados	


	#region metodos publicos

	
	
	#region IEgresoDom Members
	
	/// <summary>
    /// Metodo que permite buscar los elementos de tipo egreso existentes
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
    /// <param name="p_Filtro">informacion de filtrado para realizar la busqueda</param>
    /// <returns>objeto contenedor de la informacion generada por la accion ejecutada</returns>	
	public List<EgresoDTO> BuscarEgresoFiltro(ContextoDTO p_Contexto, EgresoDTO p_Filtro)
	{
		//Prefijo del Metodo
        const string MPREFIX = " [Buscar(ContextoDTO, EgresoDTO)]";
        //Crea lista de objetos de salida
        List<EgresoDTO> RespuestaBuscar = new List<EgresoDTO>();

        try
        {
            //Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);

            //Valida que exista informacion a insertar
            AssertNull.notNullOrEmpty(p_Filtro);

			//Obtengo la lista de objetos almacenados en la base de datos
			RespuestaBuscar = Buscar(p_Contexto, p_Filtro);
				
            //Registro log de termino OK del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Ok);
            //Registro log de ejecucion el termino del metodo
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
		catch (ManagerException me)
		{
            throw (me);
		}
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
        return RespuestaBuscar;
	}

	/// <summary>
    /// metodo que permite buscar los elementos de tipo egreso existentes
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
    /// <param name="p_IdEgreso">informacion por el Id de la tabla Egreso</param>
    /// <returns>objeto contenedor de la informacion generada por la accion ejecutada</returns>	
	public EgresoDTO BuscarEgresoPorId(ContextoDTO p_Contexto, System.Int32? p_IdEgreso)
	{
		//Prefijo del Metodo
        const string MPREFIX = " [Buscar(ContextoDTO, EgresoDTO)]";
        //Crea lista de objetos de salida
        EgresoDTO RespuestaBuscar = new EgresoDTO();

        try
        {
            //Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);

            //Valida que exista informacion a insertar
            AssertNull.notNullOrEmpty(p_IdEgreso);

			//Obtengo la lista de objtos almacenados en la base de datos
			RespuestaBuscar = Buscar(p_Contexto, p_IdEgreso);
            //Registro log de termino OK del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Ok);
            //Registro log de ejecucion el termino del metodo
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
		catch (ManagerException me)
		{
            throw (me);
		}
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
        return RespuestaBuscar;
	}

	/// <summary>
    /// metodo que permite buscar los elementos de tipo egreso existentes
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
    /// <param name="p_Filtro">informacion de filtrado para realizar la busqueda</param>
    /// <returns>objeto contenedor de la informacion generada por la accion ejecutada</returns>	
	public List<EgresoDTO> BuscarEgresoTodos(ContextoDTO p_Contexto)
	{
		//Prefijo del Metodo
        const string MPREFIX = " [Buscar(ContextoDTO, EgresoDTO)]";
        //Crea lista de objetos de salida
        List<EgresoDTO> RespuestaBuscar = new List<EgresoDTO>();

        try
        {
            //Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);

			//Obtengo la lista de objetos almacenados
			RespuestaBuscar = Buscar(p_Contexto);

            //Registro log de termino OK del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Ok);
            //Registro log de ejecucion el termino del metodo
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
		catch (ManagerException me)
		{
            throw (me);
		}
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
        return RespuestaBuscar;
	}

    /// <summary>
    /// metodo que permite registrar elementos de tipo egreso en el sistema
    /// </summary>
    /// <param name="p_Contexto">informacion del contexto</param>
    /// <param name="p_Egreso">egreso a registrar (insertar, actualizar o eliminar)</param>
    /// <param name="p_Accion">Accion a realizar</param>
    public List<EgresoDTO> RegistrarEgreso(ContextoDTO p_Contexto, List<EgresoDTO> p_Egresos, EnumRegistrarAccion p_Accion)
	{
        //Prefijo del Metodo
        const String MPREFIX = " [Registrar]";
		//Resultado accion insertar
		List<EgresoDTO> Resultado_Insertar = new List<EgresoDTO>();
        try
        {
            //Registro log de inicio del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Inicio);

            //Valida que exista informacion en el objeto
            AssertNull.notNullOrEmpty(p_Egresos);
            //Realiza la accion solicitada
            switch (p_Accion)
            {
                case EnumRegistrarAccion.Agregar:
                    Resultado_Insertar = InsertarEgreso(p_Contexto, p_Egresos);
                    break;
                case EnumRegistrarAccion.Modificar:
                    ModificarEgreso(p_Contexto, p_Egresos);
                    break;
                case EnumRegistrarAccion.Eliminar:
                    EliminarEgreso(p_Contexto, p_Egresos);
                    break;
                default:
                    break;
            }

            //Registro log de termino OK del proceso
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Ok);
            //Registro log de ejecucion el termino del metodo
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Termino);
        }
        catch (ManagerException me)
        {
            throw (me);
        }
        catch (ArquitecturaException ae)
        {
            throw (ae);
        }
        catch (Exception ex)
        {
            //Registro log de ejecucion con problemas
            Factoria.Log.Info(CLASS_PREFIX + MPREFIX + EnumMessagesEntry.Ejecucion_Problemas);
            //Genero error
            throw new ManagerException(Factoria.GetMessage("DOM_ERROR_NO_MANEJADO"), ex);
        }
		return Resultado_Insertar;
	}	
    #endregion IEgresoDom Members
    #endregion metodos publicos

	}//End class EgresoDom
}//End namespace





